package org.imsoss.util;

import java.util.ArrayList;
import java.util.Properties;

import javax.sip.ClientTransaction;
import javax.sip.DialogTerminatedEvent;
import javax.sip.IOExceptionEvent;
import javax.sip.ListeningPoint;
import javax.sip.PeerUnavailableException;
import javax.sip.RequestEvent;
import javax.sip.ResponseEvent;
import javax.sip.SipFactory;
import javax.sip.SipListener;
import javax.sip.SipProvider;
import javax.sip.SipStack;
import javax.sip.TransactionTerminatedEvent;
import javax.sip.address.Address;
import javax.sip.address.AddressFactory;
import javax.sip.address.SipURI;
import javax.sip.header.CSeqHeader;
import javax.sip.header.CallIdHeader;
import javax.sip.header.ContactHeader;
import javax.sip.header.ContentTypeHeader;
import javax.sip.header.FromHeader;
import javax.sip.header.HeaderFactory;
import javax.sip.header.MaxForwardsHeader;
import javax.sip.header.ToHeader;
import javax.sip.header.ViaHeader;
import javax.sip.message.MessageFactory;
import javax.sip.message.Request;

public class SipMessageDelegator implements SipListener  {

	SipProvider sipProvider = null;
	SipFactory sipFactory = null;
	SipStack sipStack = null;
	ListeningPoint udpListeningPoint = null;
	// If you want to try TCP transport change the following to
	String transport = "udp";
	String peerHostPort = "127.0.0.1:5080";
	public SipMessageDelegator(){
		sipFactory = SipFactory.getInstance();
		sipFactory.setPathName("gov.nist");		
		
		Properties properties = new Properties();
		
		// String peerHostPort = "230.0.0.1:5070";
		properties.setProperty("javax.sip.OUTBOUND_PROXY", peerHostPort + "/"+ transport);
		// If you want to use UDP then uncomment this.
		properties.setProperty("javax.sip.STACK_NAME", "testimsoss");

		// The following properties are specific to nist-sip
		// and are not necessarily part of any other jain-sip
		// implementation.
		// You can set a max message size for tcp transport to
		// guard against denial of service attack.
		properties.setProperty("gov.nist.javax.sip.DEBUG_LOG","shootistdebug.txt");
		properties.setProperty("gov.nist.javax.sip.SERVER_LOG","shootistlog.txt");

		// Drop the client connection after we are done with the transaction.
		//properties.setProperty("gov.nist.javax.sip.CACHE_CLIENT_CONNECTIONS","false");
		// Set to 0 (or NONE) in your production code for max speed.
		// You need 16 (or TRACE) for logging traces. 32 (or DEBUG) for debug + traces.
		// Your code will limp at 32 but it is best for debugging.
		//properties.setProperty("gov.nist.javax.sip.TRACE_LEVEL", "DEBUG");

		
		try {
			// Create SipStack object
			sipStack = sipFactory.createSipStack(properties);
			System.out.println("createSipStack " + sipStack);
		} catch (PeerUnavailableException e) {
			// could not find
			// gov.nist.jain.protocol.ip.sip.SipStackImpl
			// in the classpath
			e.printStackTrace();
			System.err.println(e.getMessage());
			System.exit(0);
		}		
		try
		{
		udpListeningPoint = sipStack.createListeningPoint("127.0.0.1", 5073, "udp");
		sipProvider = sipStack.createSipProvider(udpListeningPoint);
		SipMessageDelegator listener = this;
		sipProvider.addSipListener(listener);
		}
		catch(Exception exp)
		{
			System.out.println("Error is here::: "+exp);
		}
		System.out.println("Here is the sipProvider:"+sipProvider);
	}
	public void createRegister() 
	{
		AddressFactory addressFactory = null;
		MessageFactory messageFactory = null;
		HeaderFactory headerFactory = null;
		ContactHeader contactHeader = null;
		
		ClientTransaction registerTid = null;
		try {
			headerFactory = sipFactory.createHeaderFactory();
			addressFactory = sipFactory.createAddressFactory();
			messageFactory = sipFactory.createMessageFactory();
			

			String fromName = "p-cscf";
			String fromSipAddress = "imsoss.org";
			String fromDisplayName = "The IMS Client";

			String toSipAddress = "imsoss.org";
			String toUser = "p-cssf";
			String toDisplayName = "The IMS EntryPoint";

			// create >From Header
			SipURI fromAddress = addressFactory.createSipURI(fromName,fromSipAddress);

			Address fromNameAddress = addressFactory.createAddress(fromAddress);
			fromNameAddress.setDisplayName(fromDisplayName);
			FromHeader fromHeader = headerFactory.createFromHeader(fromNameAddress, "12345");

			// create To Header
			SipURI toAddress = addressFactory.createSipURI(toUser, toSipAddress);
			Address toNameAddress = addressFactory.createAddress(toAddress);
			toNameAddress.setDisplayName(toDisplayName);
			ToHeader toHeader = headerFactory.createToHeader(toNameAddress,null);

			// create Request URI
			SipURI requestURI = addressFactory.createSipURI(toUser,peerHostPort);

			// Create ViaHeaders
			System.out.println("**1**"+sipProvider+"-->"+sipProvider.getListeningPoint(transport));
			ArrayList viaHeaders = new ArrayList();
			String ipAddress = udpListeningPoint.getIPAddress();
			ViaHeader viaHeader = headerFactory.createViaHeader(ipAddress,sipProvider.getListeningPoint(transport).getPort(),transport,null);
			System.out.println("**123**");
			// add via headers
			viaHeaders.add(viaHeader);

			// Create ContentTypeHeader
			ContentTypeHeader contentTypeHeader = headerFactory
					.createContentTypeHeader("application", "sdp");
			System.out.println("**1234**");
			// Create a new CallId header
			CallIdHeader callIdHeader = sipProvider.getNewCallId();

			// Create a new Cseq header
			CSeqHeader cSeqHeader = headerFactory.createCSeqHeader(1L,
					Request.REGISTER);
			System.out.println("**2**");
			// Create a new MaxForwardsHeader
			MaxForwardsHeader maxForwards = headerFactory
					.createMaxForwardsHeader(70);

			// Create the request.
			Request request = messageFactory.createRequest(requestURI,
					Request.REGISTER, callIdHeader, cSeqHeader, fromHeader,
					toHeader, viaHeaders, maxForwards);
			
			/*
			// Create contact headers
			String host = "127.0.0.1";

			SipURI contactUrl = addressFactory.createSipURI(fromName, host);
			contactUrl.setPort(udpListeningPoint.getPort());
			contactUrl.setLrParam();

			// Create the contact name address.
			SipURI contactURI = addressFactory.createSipURI(fromName, host);
			contactURI.setPort(sipProvider.getListeningPoint(transport)
					.getPort());

			Address contactAddress = addressFactory.createAddress(contactURI);

			// Add the contact address.
			contactAddress.setDisplayName(fromName);

			contactHeader = headerFactory.createContactHeader(contactAddress);
			request.addHeader(contactHeader);

			// You can add extension headers of your own making
			// to the outgoing SIP request.
			// Add the extension header.
			Header extensionHeader = headerFactory.createHeader("My-Header",
					"my header value");
			request.addHeader(extensionHeader);

			String sdpData = "v=0\r\n"
					+ "o=4855 13760799956958020 13760799956958020"
					+ " IN IP4  129.6.55.78\r\n" + "s=mysession session\r\n"
					+ "p=+46 8 52018010\r\n" + "c=IN IP4  129.6.55.78\r\n"
					+ "t=0 0\r\n" + "m=audio 6022 RTP/AVP 0 4 18\r\n"
					+ "a=rtpmap:0 PCMU/8000\r\n" + "a=rtpmap:4 G723/8000\r\n"
					+ "a=rtpmap:18 G729A/8000\r\n" + "a=ptime:20\r\n";
			byte[] contents = sdpData.getBytes();

			request.setContent(contents, contentTypeHeader);
			// You can add as many extension headers as you
			// want.

			extensionHeader = headerFactory.createHeader("My-Other-Header",
					"my new header value ");
			request.addHeader(extensionHeader);

			Header callInfoHeader = headerFactory.createHeader("Call-Info",
					"<http://www.antd.nist.gov>");
			request.addHeader(callInfoHeader);
			
			*/
			// Create the client transaction.
			registerTid = sipProvider.getNewClientTransaction(request);

			// send the request out.
			registerTid.sendRequest();
			System.out.println("**3**");
			//dialog = inviteTid.getDialog();
			

		} catch (Exception ex) {
			System.out.println(ex.getMessage());
			ex.printStackTrace();
			//usage();
		}
	}

	public void processIOException(IOExceptionEvent exceptionEvent) {
		System.out.println("IOException happened for "
				+ exceptionEvent.getHost() + " port = "
				+ exceptionEvent.getPort());

	}

	public void processTransactionTerminated(
			TransactionTerminatedEvent transactionTerminatedEvent) {
		System.out.println("Transaction terminated event recieved");
	}

	public void processDialogTerminated(
			DialogTerminatedEvent dialogTerminatedEvent) {
		System.out.println("dialogTerminatedEvent");

	}
	public void processTimeout(javax.sip.TimeoutEvent timeoutEvent) {

		System.out.println("Transaction Time out");
	}

	public void processResponse(ResponseEvent responseReceivedEvent) {
		System.out.println("Inside the processResponse");
	}
	
	public void processRequest(RequestEvent requestReceivedEvent) {
		System.out.println("Inside the processRequest");
	}
}
